doc/source/examples/circuit/Voltages and Currents in Circuits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Voltages and Currents in Circuits\n",
    "The scikit-rf `Circuit` object allows one to deduce the voltages and currents at all the intersections of the circuit for a given power (and phase) excitation at circuit's ports. Here, few examples are examined, in order to clarify the conventions used for current directions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# standard imports\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import skrf as rf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf.stylely()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple transmission line\n",
    "To start, let's assume a simple transmission line excited by a generator. Let's assume the generator is matched to the line ($Z_s=Z_0$) and the line connected to a matched load ($Z_0=Z_L$), all 50 Ohm. \n",
    "\n",
    "<img src=\"circuit_vi_simple_line.svg\">\n",
    "\n",
    "What is the RF currents and voltages at the input and output of this line for a given input power (and phase)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P_f = 1  # forward power in Watt\n",
    "Z = 50  # source internal impedance, line characteristic impedance and load impedance\n",
    "L = 10  # line length in [m]\n",
    "\n",
    "freq = rf.Frequency(2, 2, 1, unit='GHz')\n",
    "line_media = rf.media.DefinedGammaZ0(freq, z0=Z)  # lossless line medium\n",
    "line = line_media.line(d=L, unit='m', name='line')  # transmission line Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming the source generates an input power of $P_f$ with a phase $\\phi$, with such a line the voltage and current at the entrance of the line are:\n",
    "\n",
    "$$\n",
    "V_{in} = \\sqrt{2 Z_0 P_f} e^{j \\phi}\n",
    "$$\n",
    "\n",
    "$$\n",
    "I_{in} = \\sqrt{2 \\frac{P_f}{Z_0}} e^{j \\phi}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V_in = np.sqrt(2*Z*P_f)\n",
    "I_in = np.sqrt(2*P_f/Z)\n",
    "print(f'Input voltage and current: {V_in} V and {I_in} A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The voltage and current evolve along the transmission line. The voltage and current at the output of the line can be calculated using the transmission line tools provided with scikit-rf:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = rf.theta(line_media.gamma, freq.f, L)  # electrical length \n",
    "V_out, I_out = rf.tlineFunctions.voltage_current_propagation(V_in, I_in, Z, theta)\n",
    "print(f'Output voltage and current: {V_out} V and {I_out} A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's perform the same calculation using `Circuit`. First, one needs to define the circuit, that is to create input/output ports and to connect these ports to the transmission line Network we've already created. Then, we can build the circuit: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "port1 = rf.Circuit.Port(frequency=freq, name='port1', z0=50)\n",
    "port2 = rf.Circuit.Port(frequency=freq, name='port2', z0=50)\n",
    "cnx = [\n",
    "    [(port1, 0), (line, 0)],\n",
    "    [(port2, 0), (line, 1)]\n",
    "]\n",
    "crt = rf.Circuit(cnx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's always a good practice to check if the circuit's graph is as expected. In this case, the graph is pretty simple: 2 ports connected to a 2-ports Network. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crt.plot_graph(network_labels=True, edge_labels=True, inter_labels=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Circuit` provides two methods to determine voltages and currents at the circuit input/output ports (also known as \"external ports\"). These methods take as input the power and phase inputs at each ports:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "power = [1, 0]  # 1 Watt at port1 and 0 at port2\n",
    "phase = [0, 0]  # 0 radians"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V_at_ports = crt.voltages_external(power, phase)\n",
    "print(V_at_ports)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "I_at_ports = crt.currents_external(power, phase)\n",
    "print(I_at_ports)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are similar to the previous, except the sign of the current at port2 which is reversed. \n",
    "\n",
    "This is normal, as the `currents_external()` method defines the positive direction of a current as the direction which \"enters\" into the circuit. More details about this convention at the bottom of this example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A coaxial T with different characteristic impedances\n",
    "As a more advanced example, we've built in a full-wave software (here ANSYS HFSS, but other are fine too) the following structure: a coaxial T, defined with different coaxial cross-sections (and such different characteristic impedances). \n",
    "\n",
    "<img src=\"circuit_vi_HFSS_Coaxial_T.png\" with=\"800\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the three ports are excited with different power and phase to complicate a bit, as the following:\n",
    "\n",
    "| port |  power [W] | phase [deg] |\n",
    "| --- | --- | --- |\n",
    "| #1 | 1 | -10 |\n",
    "| #2 | 2 | -20 |\n",
    "| #3 | 3 | +60 |\n",
    "\n",
    "### Full-wave reference solution\n",
    "The voltages and currents are evaluated in the full-wave software directly. Voltage is obtained by integrating the E fields along a straight line going from the inner to the outer conductors in the port's cross-sections. Current is obtained by integrating the H fields along a circle enclosing the inner conductor in port's cross-sections. Note the circles are directed in order to define the positive current direction as the direction inward the ports (right-hand rule). \n",
    "\n",
    "The full-wave solutions are given here for reference, at 3 frequencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd  # convenient to read .csv files\n",
    "pd.read_csv('circuit_vi_HFSS_Voltages.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('circuit_vi_HFSS_Currents.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In a Circuit simulator\n",
    "The voltages and currents can also be derived using a Circuit simulator, like for example:\n",
    "\n",
    "<img src=\"circuit_vi_Designer_circuit.png\" width=\"800\">\n",
    "\n",
    "(where, again, the current probes are oriented in such a way that the current is positive when flowing in the Network). This gives essentially the same results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('circuit_vi_Designer_Voltages.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('circuit_vi_Designer_Currents.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With `Circuit`\n",
    "Now let's build the same circuit with scikit-rf `Circuit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the 3-port .s3p file exported from full-wave simulation\n",
    "coaxial_T = rf.Network('circuit_vi_Coaxial_T.s3p')\n",
    "# pay attention to the port's characteristic impedance\n",
    "# it should match the Network characteristic impedances otherwise this will generate mismatches \n",
    "port1 = rf.Circuit.Port(coaxial_T.frequency, 'port1', coaxial_T.z0[:,0])\n",
    "port2 = rf.Circuit.Port(coaxial_T.frequency, 'port2', coaxial_T.z0[:,1])\n",
    "port3 = rf.Circuit.Port(coaxial_T.frequency, 'port3', coaxial_T.z0[:,2])\n",
    "# connexion list\n",
    "cnx = [\n",
    "    [(port1, 0), (coaxial_T, 0)],\n",
    "    [(port2, 0), (coaxial_T, 1)],\n",
    "    [(port3, 0), (coaxial_T, 2)]\n",
    "]\n",
    "# building the circuit\n",
    "crt = rf.Circuit(cnx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's check if our connexion list is correctly defined\n",
    "crt.plot_graph(network_labels=True, edge_labels=True, inter_labels=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The voltages and currents at the ports for the given excitation is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "power = [1, 2, 3]  # input power in watts at ports 1, 2 and 3\n",
    "phase = np.deg2rad([-10, -20, +60])  # input phase in rad at ports 1, 2 and 3\n",
    "\n",
    "voltages = crt.voltages_external(power, phase)\n",
    "currents = crt.currents_external(power, phase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just for a better rendering in the notebook \n",
    "pd.concat([\n",
    "    pd.DataFrame(np.abs(voltages), columns=['mag V1', 'mag V2', 'mag V3'], index=crt.frequency.f/1e6),\n",
    "    pd.DataFrame(np.angle(voltages, deg=True), columns=['Phase V1', 'Phase V2', 'Phase V3'], index=crt.frequency.f/1e6)\n",
    "], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just for a better rendering in the notebook \n",
    "pd.concat([\n",
    "    pd.DataFrame(np.abs(currents), columns=['mag I1', 'mag I2', 'mag I3'], index=crt.frequency.f/1e6),\n",
    "    pd.DataFrame(np.angle(currents, deg=True), columns=['Phase I1', 'Phase I2', 'Phase I3'], index=crt.frequency.f/1e6)\n",
    "], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results matches well the one given by the full-wave calculations, hourra. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## external vs internal ports? \n",
    "You have maybe noticed in the `Circuit` documentation that we often talk about \"internal\" or \"inner\" ports, and of \"external\" or \"outer\" ports. The external ports corresponds to the `Circuit.Port()` Networks defined when building a `Circuit`. The internal ports are all the other connexions inside the `Circuit`\n",
    "\n",
    "The `Circuit` algorithm allows one to have access to the voltages and current at the internal connexions inside the circuit. In the previous examples, there is not too much internal ports as we've connected a N-port directly to external ports. However, in more complex usages we can have a lot (look to the other `Circuit` examples).\n",
    "\n",
    "In `Circuit`, voltages and currents are peak values. While voltages are defined in a non-ambiguous manner, positive currents can be defined in a way or another, leading to a 180 degree ambiguity. To solve this, we have chosen the following definition: internal currents are defined such as they are measured positive when flowing into Networks. \n",
    "\n",
    "Hence, you find that \"external\" current are sign opposite of \"internal\" ones at the corresponding ports, because the internal currents are actually flowing into the ports Networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# internals currents (currents at all connexions)\n",
    "# in this example, there are 6 internal connexions (3 pairs of connexions)\n",
    "crt.currents(power, phase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This gives the indices of the \"external\" ports\n",
    "crt.port_indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So we can keep only \"external\" ports\n",
    "crt.currents(power, phase)[:, crt.port_indexes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note the sign difference due to the convention chosen for internal ports\n",
    "crt.currents_external(power, phase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The figure below illustrates these differences using the previous example:\n",
    "\n",
    "<img src=\"circuit_vi_convention_currents.png\" width=\"800\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 ('.venv': venv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "637c323cf467337602e9974a89cb4d3fc95fac3ef875a73e62754f8e768d8de7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}